home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / share / idl / bonobo-2.0 / Bonobo_Persist.idl < prev    next >
Encoding:
Text File  |  2009-03-09  |  4.1 KB  |  187 lines
  1. /*
  2.  * bonobo-persist.idl: Bonobo::Persist interfaces
  3.  *
  4.  * Copyright (C) 1999, 2000  Helix Code, Inc.
  5.  *
  6.  * Authors:
  7.  *    Miguel de Icaza (miguel@gnu.org)
  8.  *    Dan Winship     (danw@helixcode.com)
  9.  */
  10.  
  11. #ifndef BONOBO_PERSIST_IDL
  12. #define BONOBO_PERSIST_IDL
  13.  
  14. #include "Bonobo_Unknown.idl"
  15. #include "Bonobo_Storage.idl"
  16. #include "Bonobo_Exception.idl"
  17.  
  18. module Bonobo {
  19.  
  20.     interface Persist : Unknown {
  21.         enum Status {
  22.             SAVE_OK,
  23.             SAVE_CANCEL,
  24.             SAVE_FAILED
  25.         };
  26.  
  27.         exception WrongDataType {};
  28.         exception FileNotFound {};
  29.  
  30.         typedef string                ContentType;
  31.         typedef sequence<ContentType> ContentTypeList;
  32.         
  33.         /**
  34.          * getContentTypes:
  35.          *
  36.          *  Gets a list of supported mime types that this
  37.          * persistor can save its data in. The default /
  38.          * preferred type being the first element.
  39.          */
  40.         ContentTypeList getContentTypes ();
  41.  
  42.         typedef string                IID;
  43.         
  44.         /**
  45.          * getIId:
  46.          *
  47.          * Get the IID necessary to recreate the object whose
  48.          * internal state this interface represents
  49.          */
  50.         IID getIId ();
  51.  
  52.         /**
  53.          * isDirty:
  54.          * 
  55.          * Indicates if a save is necessary.
  56.          */
  57.         boolean isDirty ();
  58.     
  59.         void unImplemented1 ();
  60.         void unImplemented2 ();
  61.     };
  62.     
  63.     /*
  64.      * The PersistFile interface is somewhat mis-named it
  65.      * should be PersistURI.
  66.      *
  67.      * This allows applications to load and save documents
  68.      * via the Gnome VFS.
  69.      */
  70.     interface PersistFile : Persist {
  71.  
  72.             exception NoCurrentName {
  73.             string extension;
  74.         };
  75.  
  76.         /**
  77.          * load:
  78.          * @uri: URI to load from
  79.          * 
  80.          * Loads the document object from the file
  81.          * pointed in by @path
  82.          */
  83.         void load (in string uri)
  84.             raises (IOError, NotSupported,
  85.                 WrongDataType, FileNotFound);
  86.  
  87.         /**
  88.          * save:
  89.          * @uri: the URI to save to
  90.          * saves the document object to the file 
  91.          * pointed in by @path
  92.          */
  93.         void save (in string uri)
  94.             raises (IOError, NotSupported);
  95.     
  96.         /**
  97.          * getCurrentFile:
  98.          * 
  99.          * Returns the URI of the current file. 
  100.          */
  101.         string getCurrentFile ()
  102.             raises (NoCurrentName);
  103.  
  104.         void unImplemented3 ();
  105.         void unImplemented4 ();
  106.     };
  107.  
  108.     /*
  109.      * PersistStorage is implemented by BonoboObjects.
  110.      * 
  111.      * The methods are used by Bonobo and the container
  112.      * applications to manipulate the storage of a componet
  113.      */
  114.     interface PersistStorage : Persist {
  115.         
  116.         /**
  117.          * load:
  118.          * @storage: The storage to load the state from
  119.          *
  120.          * The bonobo_object should load its state from the
  121.          * @storage provided
  122.          */
  123.         void load (in Bonobo::Storage storage)
  124.             raises (IOError, NotSupported,
  125.                 WrongDataType);
  126.  
  127.         /**
  128.          * save:
  129.          * @storage: The storage in which to save the state
  130.          * of the bonobo_object
  131.          * @same_as_loaded: if TRUE, this means the object
  132.          * is being saved to the same source used to load the object
  133.          *
  134.          * BonoboObjects should save their sate in the @storage
  135.          */
  136.         void save (in Bonobo::Storage storage,
  137.                in boolean same_as_loaded)
  138.             raises (IOError, NotSupported);
  139.     };
  140.     
  141.     /*
  142.      * This interface is used by items which only need to store 
  143.      * information in a Stream ( monikers are the primary
  144.      * users of this ).  
  145.      *
  146.      * Unlike PersistStorage, the Stream passed is only valid
  147.      * during these calls (ie, you should not incref these
  148.      * and used them after this).
  149.      */
  150.     interface PersistStream : Persist {
  151.         
  152.         /**
  153.          * load:
  154.          * @stream: Where to load the state from
  155.          * @type: the MIME content type of the data, or ""
  156.          * if it is unknown.
  157.          *
  158.          * Loads the status of the object from @stream
  159.          */
  160.         void load (in Bonobo::Stream stream, in ContentType type)
  161.             raises (IOError, NotSupported,
  162.                 WrongDataType);
  163.  
  164.         /**
  165.          * save:
  166.          * @stream: Where to save the state to.
  167.          * @type: the MIME content type to save the data in,
  168.          * or "" if any type is acceptable.
  169.          *
  170.          * If no exception was thrown the data in the stream has
  171.          * the requested content type; if no type was requested
  172.          * the first entry from getContentTypes is returned.
  173.          * Hence no return value is needed.
  174.          * 
  175.          * Saves the state of the object to the @stream
  176.          */
  177.         void save (in Bonobo::Stream stream, in ContentType type)
  178.             raises (IOError, NotSupported,
  179.                 WrongDataType);
  180.  
  181.         void unImplemented3 ();
  182.         void unImplemented4 ();
  183.     };
  184. };
  185.  
  186. #endif /* BONOBO_PERSIST_IDL */
  187.